package com.school.sports.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.school.sports.entity.SystemConfig;
import com.school.sports.service.SystemConfigService;
import com.school.sports.common.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;
import java.util.Map;

/**
 * 系统配置管理控制器
 * 提供系统参数配置的CRUD操作、缓存刷新等功能
 */
@RestController
@RequestMapping("/api/system-config")
public class SystemConfigController {

    private static final Logger logger = LoggerFactory.getLogger(SystemConfigController.class);

    @Autowired
    private SystemConfigService systemConfigService;

    /**
     * 分页查询系统配置列表
     * @param currentPage 当前页码
     * @param pageSize 每页大小
     * @param systemConfig 查询条件
     * @return 分页结果
     */
    @GetMapping("/page/{currentPage}/{pageSize}")
    @PreAuthorize("hasRole('管理员')")
    public Result<IPage<SystemConfig>> getSystemConfigPage(
            @PathVariable("currentPage") Integer currentPage,
            @PathVariable("pageSize") Integer pageSize,
            SystemConfig systemConfig) {

        logger.info("分页查询系统配置列表，当前页码：{}，每页条数：{}，查询条件：{}", currentPage, pageSize, systemConfig);

        // 参数校验
        if (currentPage == null || currentPage <= 0) {
            currentPage = 1;
        }
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
        }

        try {
            IPage<SystemConfig> page = systemConfigService.getSystemConfigPage(currentPage, pageSize, systemConfig);
            logger.info("查询系统配置列表成功，共{}条记录", page.getTotal());
            return Result.success(page);
        } catch (Exception e) {
            logger.error("查询系统配置列表异常：{}", e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 根据ID查询系统配置详情
     * @param configId 配置ID
     * @return 配置详情
     */
    @GetMapping("/{configId}")
    @PreAuthorize("hasRole('管理员')")
    public Result<SystemConfig> getSystemConfigById(@PathVariable("configId") Long configId) {
        logger.info("查询系统配置详情，配置ID：{}", configId);

        if (configId == null || configId <= 0) {
            return Result.fail("配置ID无效");
        }

        try {
            SystemConfig config = systemConfigService.getById(configId);
            if (config == null) {
                return Result.fail("配置不存在");
            }
            logger.info("查询系统配置详情成功，配置键：{}", config.getConfigKey());
            return Result.success(config);
        } catch (Exception e) {
            logger.error("查询系统配置详情异常：{}", e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 根据配置键获取配置值
     * @param configKey 配置键
     * @return 配置值
     */
    @GetMapping("/value/{configKey}")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生', '裁判')")
    public Result<String> getConfigValue(@PathVariable("configKey") String configKey) {
        logger.info("获取配置值，配置键：{}", configKey);

        if (configKey == null || configKey.trim().isEmpty()) {
            return Result.fail("配置键不能为空");
        }

        try {
            String configValue = systemConfigService.getConfigValue(configKey);
            if (configValue == null) {
                return Result.fail("配置不存在或已停用");
            }
            logger.info("获取配置值成功，配置键：{}", configKey);
            return Result.success(configValue);
        } catch (Exception e) {
            logger.error("获取配置值异常：{}", e.getMessage(), e);
            return Result.fail("获取失败：" + e.getMessage());
        }
    }

    /**
     * 根据配置类型获取配置列表
     * @param configType 配置类型
     * @return 配置列表
     */
    @GetMapping("/type/{configType}")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生', '裁判')")
    public Result<List<SystemConfig>> getConfigsByType(@PathVariable("configType") String configType) {
        logger.info("根据配置类型获取配置列表，配置类型：{}", configType);

        if (configType == null || configType.trim().isEmpty()) {
            return Result.fail("配置类型不能为空");
        }

        try {
            List<SystemConfig> configs = systemConfigService.getConfigsByType(configType);
            logger.info("获取配置列表成功，配置类型：{}，共{}个配置", configType, configs.size());
            return Result.success(configs);
        } catch (Exception e) {
            logger.error("获取配置列表异常：{}", e.getMessage(), e);
            return Result.fail("获取失败：" + e.getMessage());
        }
    }

    /**
     * 新增系统配置
     * @param systemConfig 配置信息
     * @return 操作结果
     */
    @PostMapping
    @PreAuthorize("hasRole('管理员')")
    public Result<String> addSystemConfig(@Valid @RequestBody SystemConfig systemConfig) {
        logger.info("新增系统配置：{}", systemConfig.getConfigKey());

        try {
            // 参数校验
            if (systemConfig.getConfigKey() == null || systemConfig.getConfigKey().trim().isEmpty()) {
                return Result.fail("配置键不能为空");
            }
            if (systemConfig.getConfigValue() == null || systemConfig.getConfigValue().trim().isEmpty()) {
                return Result.fail("配置值不能为空");
            }

            // 获取当前用户ID（这里简化处理，实际应该从Spring Security上下文中获取）
            Long currentUserId = getCurrentUserId();

            boolean success = systemConfigService.addSystemConfig(systemConfig, currentUserId);
            if (success) {
                logger.info("新增系统配置成功：{}", systemConfig.getConfigKey());
                return Result.success("添加成功");
            } else {
                return Result.fail("添加失败，配置键可能已存在");
            }
        } catch (Exception e) {
            logger.error("新增系统配置异常：{}", e.getMessage(), e);
            return Result.fail("添加失败：" + e.getMessage());
        }
    }

    /**
     * 更新系统配置
     * @param systemConfig 配置信息
     * @return 操作结果
     */
    @PutMapping
    @PreAuthorize("hasRole('管理员')")
    public Result<String> updateSystemConfig(@Valid @RequestBody SystemConfig systemConfig) {
        logger.info("更新系统配置：{}", systemConfig.getId());

        if (systemConfig.getId() == null || systemConfig.getId() <= 0) {
            return Result.fail("配置ID无效");
        }

        try {
            // 获取当前用户ID
            Long currentUserId = getCurrentUserId();

            boolean success = systemConfigService.updateSystemConfig(systemConfig, currentUserId);
            if (success) {
                logger.info("更新系统配置成功：{}", systemConfig.getId());
                return Result.success("更新成功");
            } else {
                return Result.fail("更新失败，配置不存在或配置键已存在");
            }
        } catch (Exception e) {
            logger.error("更新系统配置异常：{}", e.getMessage(), e);
            return Result.fail("更新失败：" + e.getMessage());
        }
    }

    /**
     * 删除系统配置
     * @param configId 配置ID
     * @return 操作结果
     */
    @DeleteMapping("/{configId}")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> deleteSystemConfig(@PathVariable("configId") Long configId) {
        logger.info("删除系统配置：{}", configId);

        if (configId == null || configId <= 0) {
            return Result.fail("配置ID无效");
        }

        try {
            boolean success = systemConfigService.deleteSystemConfig(configId);
            if (success) {
                logger.info("删除系统配置成功：{}", configId);
                return Result.success("删除成功");
            } else {
                return Result.fail("删除失败，配置不存在或为内置配置");
            }
        } catch (Exception e) {
            logger.error("删除系统配置异常：{}", e.getMessage(), e);
            return Result.fail("删除失败：" + e.getMessage());
        }
    }

    /**
     * 批量删除系统配置
     * @param configIds 配置ID列表
     * @return 操作结果
     */
    @DeleteMapping("/batch")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> batchDeleteSystemConfigs(@RequestBody List<Long> configIds) {
        logger.info("批量删除系统配置：{}", configIds);

        if (configIds == null || configIds.isEmpty()) {
            return Result.fail("请选择要删除的配置");
        }

        try {
            boolean success = systemConfigService.batchDeleteSystemConfigs(configIds);
            if (success) {
                logger.info("批量删除系统配置成功，共{}个配置", configIds.size());
                return Result.success("批量删除成功");
            } else {
                return Result.fail("批量删除失败，可能包含内置配置");
            }
        } catch (Exception e) {
            logger.error("批量删除系统配置异常：{}", e.getMessage(), e);
            return Result.fail("批量删除失败：" + e.getMessage());
        }
    }

    /**
     * 修改配置状态
     * @param configId 配置ID
     * @param status 状态
     * @return 操作结果
     */
    @PutMapping("/{configId}/status")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> updateConfigStatus(
            @PathVariable("configId") Long configId,
            @RequestParam("status") Integer status) {

        logger.info("修改系统配置状态：{} -> {}", configId, status);

        if (configId == null || configId <= 0) {
            return Result.fail("配置ID无效");
        }

        if (status == null || (status != 0 && status != 1)) {
            return Result.fail("状态值无效");
        }

        try {
            Long currentUserId = getCurrentUserId();
            boolean success = systemConfigService.updateConfigStatus(configId, status, currentUserId);
            if (success) {
                logger.info("修改系统配置状态成功：{}", configId);
                return Result.success("状态修改成功");
            } else {
                return Result.fail("状态修改失败");
            }
        } catch (Exception e) {
            logger.error("修改系统配置状态异常：{}", e.getMessage(), e);
            return Result.fail("状态修改失败：" + e.getMessage());
        }
    }

    /**
     * 刷新配置缓存
     * @return 操作结果
     */
    @PostMapping("/refresh-cache")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> refreshConfigCache() {
        logger.info("刷新系统配置缓存");

        try {
            boolean success = systemConfigService.refreshConfigCache();
            if (success) {
                logger.info("刷新系统配置缓存成功");
                return Result.success("缓存刷新成功");
            } else {
                return Result.fail("缓存刷新失败");
            }
        } catch (Exception e) {
            logger.error("刷新系统配置缓存异常：{}", e.getMessage(), e);
            return Result.fail("缓存刷新失败：" + e.getMessage());
        }
    }

    /**
     * 获取所有启用的配置（用于缓存）
     * @return 配置键值对
     */
    @GetMapping("/all-enabled")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生', '裁判')")
    public Result<Map<String, String>> getAllEnabledConfigs() {
        logger.info("获取所有启用的系统配置");

        try {
            Map<String, String> configs = systemConfigService.getAllEnabledConfigs();
            logger.info("获取所有启用的系统配置成功，共{}个配置", configs.size());
            return Result.success(configs);
        } catch (Exception e) {
            logger.error("获取所有启用的系统配置异常：{}", e.getMessage(), e);
            return Result.fail("获取失败：" + e.getMessage());
        }
    }

    /**
     * 批量更新配置
     * @param configMap 配置键值对
     * @return 操作结果
     */
    @PutMapping("/batch")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> batchUpdateConfigs(@RequestBody Map<String, String> configMap) {
        logger.info("批量更新系统配置，共{}个配置", configMap.size());

        if (configMap == null || configMap.isEmpty()) {
            return Result.fail("请提供要更新的配置");
        }

        try {
            Long currentUserId = getCurrentUserId();
            boolean success = systemConfigService.batchUpdateConfigs(configMap, currentUserId);
            if (success) {
                logger.info("批量更新系统配置成功");
                return Result.success("批量更新成功");
            } else {
                return Result.fail("批量更新失败");
            }
        } catch (Exception e) {
            logger.error("批量更新系统配置异常：{}", e.getMessage(), e);
            return Result.fail("批量更新失败：" + e.getMessage());
        }
    }

    /**
     * 检查配置键是否存在
     * @param configKey 配置键
     * @param excludeId 排除的ID
     * @return 检查结果
     */
    @GetMapping("/check-key")
    @PreAuthorize("hasRole('管理员')")
    public Result<Boolean> checkConfigKeyExists(
            @RequestParam("configKey") String configKey,
            @RequestParam(value = "excludeId", required = false) Long excludeId) {

        logger.info("检查配置键是否存在：{}，排除ID：{}", configKey, excludeId);

        if (configKey == null || configKey.trim().isEmpty()) {
            return Result.fail("配置键不能为空");
        }

        try {
            boolean exists = systemConfigService.checkConfigKeyExists(configKey, excludeId);
            logger.info("检查配置键是否存在完成：{} -> {}", configKey, exists);
            return Result.success(exists);
        } catch (Exception e) {
            logger.error("检查配置键是否存在异常：{}", e.getMessage(), e);
            return Result.fail("检查失败：" + e.getMessage());
        }
    }

    /**
     * 获取当前用户ID
     * 这里简化处理，实际应该从Spring Security上下文中获取
     * @return 用户ID
     */
    private Long getCurrentUserId() {
        // TODO: 从Spring Security上下文中获取当前用户ID
        return 1L; // 临时返回固定值
    }
}